﻿#region Header
// ------------------------ Licence / Copyright ------------------------
// 
// Simple Service Administration Tool for WinNT based systems.
// Copyright © 2010 - Silvan Gehrig
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
// 
// Author:
//  Silvan Gehrig
//
// ---------------------------------------------------------------------
#endregion

#region Usings

using System;
using log4net;

#endregion

namespace SSATool.Common.Logging
{
    /// <summary>
    /// Contains the global utilities for the logging purposes.
    /// </summary>
    /// <remarks>
    /// The implementation of the current class follows the borg
    /// "pattern".
    /// </remarks>
    /// <typeparam name="T">Specifies the logging category.</typeparam>
    public class Logger<T>
    {
        #region Declarations
        //--------------------------------------------------------------------
        // Declarations
        //--------------------------------------------------------------------

        private static readonly ILog Log = LogManager.GetLogger(typeof (T));
        
        #endregion

        #region Constructors / Destructor
        //--------------------------------------------------------------------
        // Constructors / Destructor
        //--------------------------------------------------------------------

        /// <summary>
        /// Do not create public instances of the typed logger class.
        /// </summary>
        protected Logger()
        {
            
        }

        #endregion

        #region Properties
        //--------------------------------------------------------------------
        // Properties
        //--------------------------------------------------------------------

        /// <summary>
        /// Nested Diagnostic Context (NDC) uses a stack per thread to identify different clients. It is the developer's responsibility to put
        /// in a unique value for each client. To constrain NDC into a certain block of code, the developer can use
        /// the "using" statement to make his task easier, because it automatically pops the respective value from the stack.
        /// </summary>
        /// <param name="putValue">Specifies the Nested Diagnostic Context (NDC) value to identify different clients.</param>
        public static IDisposable StartNdc(string putValue)
        {
            return NDC.Push(putValue);
        }

        /// <summary>
        /// Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <value>
        /// <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
        /// </value>
        /// <remarks>
        /// <para>
        /// This function is intended to lessen the computational cost of
        ///             disabled log debug statements.
        /// </para>
        /// <para>
        /// For some ILog interface <c>log</c>, when you write:
        /// </para>
        /// <code lang="C#">
        /// log.Debug("This is entry number: " + i );
        /// </code>
        /// <para>
        /// You incur the cost constructing the message, string construction and concatenation in
        ///             this case, regardless of whether the message is logged or not.
        /// </para>
        /// <para>
        /// If you are worried about speed (who isn't), then you should write:
        /// </para>
        /// <code lang="C#">
        /// if (log.IsDebugEnabled)
        ///             { 
        ///                 log.Debug("This is entry number: " + i );
        ///             }
        /// </code>
        /// <para>
        /// This way you will not incur the cost of parameter
        ///             construction if debugging is disabled for <c>log</c>. On
        ///             the other hand, if the <c>log</c> is debug enabled, you
        ///             will incur the cost of evaluating whether the logger is debug
        ///             enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
        ///             the <see cref="M:log4net.ILog.Debug(System.Object)"/>.  This is an insignificant overhead
        ///             since evaluating a logger takes about 1% of the time it
        ///             takes to actually log. This is the preferred style of logging.
        /// </para>
        /// <para>
        /// Alternatively if your logger is available statically then the is debug
        ///             enabled state can be stored in a static variable like this:
        /// </para>
        /// <code lang="C#">
        /// private static readonly bool isDebugEnabled = log.IsDebugEnabled;
        /// </code>
        /// <para>
        /// Then when you come to log you can write:
        /// </para>
        /// <code lang="C#">
        /// if (isDebugEnabled)
        ///             { 
        ///                 log.Debug("This is entry number: " + i );
        ///             }
        /// </code>
        /// <para>
        /// This way the debug enabled state is only queried once
        ///             when the class is loaded. Using a <c>private static readonly</c>
        ///             variable is the most efficient because it is a run time constant
        ///             and can be heavily optimized by the JIT compiler.
        /// </para>
        /// <para>
        /// Of course if you use a static readonly variable to
        ///             hold the enabled state of the logger then you cannot
        ///             change the enabled state at runtime to vary the logging
        ///             that is produced. You have to decide if you need absolute
        ///             speed or runtime flexibility.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])"/>
        public static bool IsDebugEnabled
        {
            get { return Log.IsDebugEnabled; }
        }

        /// <summary>
        /// Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <value>
        /// <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
        /// </value>
        /// <remarks>
        /// For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object)"/><seealso cref="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static bool IsInfoEnabled
        {
            get { return Log.IsInfoEnabled; }
        }

        /// <summary>
        /// Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <value>
        /// <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
        /// </value>
        /// <remarks>
        /// For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object)"/><seealso cref="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static bool IsWarnEnabled
        {
            get { return Log.IsWarnEnabled; }
        }

        /// <summary>
        /// Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <value>
        /// <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
        /// </value>
        /// <remarks>
        /// For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object)"/><seealso cref="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static bool IsErrorEnabled
        {
            get { return Log.IsErrorEnabled; }
        }

        /// <summary>
        /// Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <value>
        /// <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
        /// </value>
        /// <remarks>
        /// For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object)"/><seealso cref="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static bool IsFatalEnabled
        {
            get { return Log.IsFatalEnabled; }
        }

        #endregion

        #region Methods
        //--------------------------------------------------------------------
        // Methods
        //--------------------------------------------------------------------

        /// <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <param name="message">The message object to log.</param>
        /// <remarks>
        /// <para>
        /// This method first checks if this logger is <c>DEBUG</c>
        ///             enabled by comparing the level of this logger with the 
        ///             <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
        ///             <c>DEBUG</c> enabled, then it converts the message object
        ///             (passed as parameter) to a string by invoking the appropriate
        ///             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
        ///             proceeds to call all the registered appenders in this logger 
        ///             and also higher in the hierarchy depending on the value of 
        ///             the additivity flag.
        /// </para>
        /// <para>
        /// <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
        ///             to this method will print the name of the <see cref="T:System.Exception"/> 
        ///             but no stack trace. To print a stack trace use the 
        ///             <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/> form instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void Debug(object message)
        {
            Log.Debug(message);
        }

        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
        ///             the stack trace of the <see cref="T:System.Exception"/> passed
        ///             as a parameter.
        /// </summary>
        /// <param name="message">The message object to log.</param><param name="exception">The exception to log, including its stack trace.</param>
        /// <remarks>
        /// <para>
        /// See the <see cref="M:log4net.ILog.Debug(System.Object)"/> form for more detailed information.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void Debug(object message, Exception exception)
        {
            Log.Debug(message, exception);
        }

        /// <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void DebugFormat(string format, params object[] args)
        {
            Log.DebugFormat(format, args);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void DebugFormat(string format, object arg0)
        {
            Log.DebugFormat(format, arg0);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void DebugFormat(string format, object arg0, object arg1)
        {
            Log.DebugFormat(format, arg0, arg1);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param><param name="arg2">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void DebugFormat(string format, object arg0, object arg1, object arg2)
        {
            Log.DebugFormat(format, arg0, arg1, arg2);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
        /// </summary>
        /// <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param><param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Debug(System.Object)"/><seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        public static void DebugFormat(IFormatProvider provider, string format, params object[] args)
        {
            Log.DebugFormat(provider, format, args);
        }

        /// <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
        /// <summary>
        /// Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <remarks>
        /// <para>
        /// This method first checks if this logger is <c>INFO</c>
        ///             enabled by comparing the level of this logger with the 
        ///             <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
        ///             <c>INFO</c> enabled, then it converts the message object
        ///             (passed as parameter) to a string by invoking the appropriate
        ///             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
        ///             proceeds to call all the registered appenders in this logger 
        ///             and also higher in the hierarchy depending on the value of the 
        ///             additivity flag.
        /// </para>
        /// <para>
        /// <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
        ///             to this method will print the name of the <see cref="T:System.Exception"/> 
        ///             but no stack trace. To print a stack trace use the 
        ///             <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/> form instead.
        /// </para>
        /// </remarks>
        /// <param name="message">The message object to log.</param><seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void Info(object message)
        {
            Log.Info(message);
        }

        /// <summary>
        /// Logs a message object with the <c>INFO</c> level including
        ///             the stack trace of the <see cref="T:System.Exception"/> passed
        ///             as a parameter.
        /// </summary>
        /// <param name="message">The message object to log.</param><param name="exception">The exception to log, including its stack trace.</param>
        /// <remarks>
        /// <para>
        /// See the <see cref="M:log4net.ILog.Info(System.Object)"/> form for more detailed information.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void Info(object message, Exception exception)
        {
            Log.Info(message, exception);
        }

        /// <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void InfoFormat(string format, params object[] args)
        {
            Log.InfoFormat(format, args);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void InfoFormat(string format, object arg0)
        {
            Log.InfoFormat(format, arg0);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void InfoFormat(string format, object arg0, object arg1)
        {
            Log.InfoFormat(format, arg0, arg1);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param><param name="arg2">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void InfoFormat(string format, object arg0, object arg1, object arg2)
        {
            Log.InfoFormat(format, arg0, arg1, arg2);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
        /// </summary>
        /// <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param><param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        public static void InfoFormat(IFormatProvider provider, string format, params object[] args)
        {
            Log.InfoFormat(provider, format, args);
        }

        /// <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <remarks>
        /// <para>
        /// This method first checks if this logger is <c>WARN</c>
        ///             enabled by comparing the level of this logger with the 
        ///             <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
        ///             <c>WARN</c> enabled, then it converts the message object
        ///             (passed as parameter) to a string by invoking the appropriate
        ///             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
        ///             proceeds to call all the registered appenders in this logger 
        ///             and also higher in the hierarchy depending on the value of the 
        ///             additivity flag.
        /// </para>
        /// <para>
        /// <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
        ///             to this method will print the name of the <see cref="T:System.Exception"/> 
        ///             but no stack trace. To print a stack trace use the 
        ///             <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/> form instead.
        /// </para>
        /// </remarks>
        /// <param name="message">The message object to log.</param><seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void Warn(object message)
        {
            Log.Warn(message);
        }

        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
        ///             the stack trace of the <see cref="T:System.Exception"/> passed
        ///             as a parameter.
        /// </summary>
        /// <param name="message">The message object to log.</param><param name="exception">The exception to log, including its stack trace.</param>
        /// <remarks>
        /// <para>
        /// See the <see cref="M:log4net.ILog.Warn(System.Object)"/> form for more detailed information.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void Warn(object message, Exception exception)
        {
            Log.Warn(message, exception);
        }

        /// <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void WarnFormat(string format, params object[] args)
        {
            Log.WarnFormat(format, args);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void WarnFormat(string format, object arg0)
        {
            Log.WarnFormat(format, arg0);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void WarnFormat(string format, object arg0, object arg1)
        {
            Log.WarnFormat(format, arg0, arg1);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param><param name="arg2">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void WarnFormat(string format, object arg0, object arg1, object arg2)
        {
            Log.WarnFormat(format, arg0, arg1, arg2);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
        /// </summary>
        /// <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param><param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        public static void WarnFormat(IFormatProvider provider, string format, params object[] args)
        {
            Log.WarnFormat(provider, format, args);
        }

        /// <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
        /// <summary>
        /// Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <param name="message">The message object to log.</param>
        /// <remarks>
        /// <para>
        /// This method first checks if this logger is <c>ERROR</c>
        ///             enabled by comparing the level of this logger with the 
        ///             <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
        ///             <c>ERROR</c> enabled, then it converts the message object
        ///             (passed as parameter) to a string by invoking the appropriate
        ///             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
        ///             proceeds to call all the registered appenders in this logger 
        ///             and also higher in the hierarchy depending on the value of the 
        ///             additivity flag.
        /// </para>
        /// <para>
        /// <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
        ///             to this method will print the name of the <see cref="T:System.Exception"/> 
        ///             but no stack trace. To print a stack trace use the 
        ///             <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/> form instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void Error(object message)
        {
            Log.Error(message);
        }

        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
        ///             the stack trace of the <see cref="T:System.Exception"/> passed
        ///             as a parameter.
        /// </summary>
        /// <param name="message">The message object to log.</param><param name="exception">The exception to log, including its stack trace.</param>
        /// <remarks>
        /// <para>
        /// See the <see cref="M:log4net.ILog.Error(System.Object)"/> form for more detailed information.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void Error(object message, Exception exception)
        {
            Log.Error(message, exception);
        }

        /// <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void ErrorFormat(string format, params object[] args)
        {
            Log.ErrorFormat(format, args);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void ErrorFormat(string format, object arg0)
        {
            Log.ErrorFormat(format, arg0);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void ErrorFormat(string format, object arg0, object arg1)
        {
            Log.ErrorFormat(format, arg0, arg1);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param><param name="arg2">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void ErrorFormat(string format, object arg0, object arg1, object arg2)
        {
            Log.ErrorFormat(format, arg0, arg1, arg2);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
        /// </summary>
        /// <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param><param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        public static void ErrorFormat(IFormatProvider provider, string format, params object[] args)
        {
            Log.ErrorFormat(provider, format, args);
        }

        /// <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <remarks>
        /// <para>
        /// This method first checks if this logger is <c>FATAL</c>
        ///             enabled by comparing the level of this logger with the 
        ///             <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
        ///             <c>FATAL</c> enabled, then it converts the message object
        ///             (passed as parameter) to a string by invoking the appropriate
        ///             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
        ///             proceeds to call all the registered appenders in this logger 
        ///             and also higher in the hierarchy depending on the value of the 
        ///             additivity flag.
        /// </para>
        /// <para>
        /// <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
        ///             to this method will print the name of the <see cref="T:System.Exception"/> 
        ///             but no stack trace. To print a stack trace use the 
        ///             <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/> form instead.
        /// </para>
        /// </remarks>
        /// <param name="message">The message object to log.</param><seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void Fatal(object message)
        {
            Log.Fatal(message);
        }

        /// <summary>
        /// Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
        ///             the stack trace of the <see cref="T:System.Exception"/> passed
        ///             as a parameter.
        /// </summary>
        /// <param name="message">The message object to log.</param><param name="exception">The exception to log, including its stack trace.</param>
        /// <remarks>
        /// <para>
        /// See the <see cref="M:log4net.ILog.Fatal(System.Object)"/> form for more detailed information.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void Fatal(object message, Exception exception)
        {
            Log.Fatal(message, exception);
        }

        /// <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void FatalFormat(string format, params object[] args)
        {
            Log.FatalFormat(format, args);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void FatalFormat(string format, object arg0)
        {
            Log.FatalFormat(format, arg0);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void FatalFormat(string format, object arg0, object arg1)
        {
            Log.FatalFormat(format, arg0, arg1);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <param name="format">A String containing zero or more format items</param><param name="arg0">An Object to format</param><param name="arg1">An Object to format</param><param name="arg2">An Object to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void FatalFormat(string format, object arg0, object arg1, object arg2)
        {
            Log.FatalFormat(format, arg0, arg1, arg2);
        }

        /// <summary>
        /// Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
        /// </summary>
        /// <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param><param name="format">A String containing zero or more format items</param><param name="args">An Object array containing zero or more objects to format</param>
        /// <remarks>
        /// <para>
        /// The message is formatted using the <c>String.Format</c> method. See
        ///             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
        ///             of the formatting.
        /// </para>
        /// <para>
        /// This method does not take an <see cref="T:System.Exception"/> object to include in the
        ///             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object)"/>
        ///             methods instead.
        /// </para>
        /// </remarks>
        /// <seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/><seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        public static void FatalFormat(IFormatProvider provider, string format, params object[] args)
        {
            Log.FatalFormat(provider, format, args);
        }

        #endregion
    }

    /// <summary>
    /// Contains the global utilities for the logging purposes. This logger
    /// will log the messages to the default Logger category.
    /// </summary>
    public class Logger : Logger<Logger>
    {
        #region Constructors / Destructor
        //--------------------------------------------------------------------
        // Constructors / Destructor
        //--------------------------------------------------------------------

        /// <summary>
        /// Do not create public instances of the logger class.
        /// </summary>
        protected Logger()
        {

        }

        #endregion
    }
}
